
#ifndef __PILE__H__
#define  __PILE_H__



#include "etat.h"

/** Structure stack
 *  Permet de manipuler des suites de données de type Etat  définis  dans etat.h
 */ 

typedef struct stack {

/** Reférence à la donnée 
 *
 */


  Etat *element;


   /** Reférence à  la cellule  suivante de la suite 
   *
   */ 
  

  struct stack *suivant;
  
}    Stack ;


/** Structure pile
 *  Permet de créer le contexte pour manipuler les suites précédentes comme des piles,
 *   c'est à dire comme des collection de données de type dernier rentré, premier sorti
 *   ( En anglais Last  in, First out soit LIFO)
 *  La structure permet en outre  de manipuler des données statistiques intéressantes 
 *  telles que la hauteur  de la plus haute  pile  utilisée lors d'un calcul
 */ 


typedef struct pile {

  /** Hauteur  de la plus haute  pile  utilisée lors d'un calcul  */ 


  int HAUTEUR_MAX_PILE;

  /** Hauteur instantanée de la pile   */

  int HAUTEUR_EFFECTIVE;

  /**    La sommet de la pile */

  Stack * sommet;

}   Pile ;



/**  Procedure libererPile
 *   Libère la mémoire occupée par la Pile
 *   La mémoire occupée par la suite d'états est elle auusi libérée
 *   La mémoire correspondant aux états de la suite est libérée
 *   Cette dernière opération est effectuée par une procédure libérerEtat qui doit être fournie
 *   La signature de la procédure  doit être 
 *       void libererEtat(Etat *e);
 *
 *    Arguments 
 *         Pile *p : la pile à libérer
 *
*/

void libererPile(Pile *p) ;



/**  Fonction  nouvellePile
 *   Crée une nouvelle pile vide
 * 
 *   Retourne:
 *              un pointeur sur la nouvelle pile  
 */



Pile *nouvellePile(void);


/**  Fonction  estVide
 *   Teste si la pile est vide 
 *
 *   Paramètre:
 *              Pile *p: la pile à tester 
 * 
 *   Retourne:
 *              O: si la pile contient au moins un Etat
 *              1: si la pile ne contient aucun Etat
 *
 *
 *   La signature forme de la fonction  est   
 *
 *            int estVide(Pile *p);
 * 
 *   L'implémentation effective est réalisé en utilisant une Macro.
 *   Ceci permet d'économiser un appel de fonction, tout en maintenant l'encapsulation.
 *
 */



 
#define pileVide(p) (!((p)->HAUTEUR_EFFECTIVE))


/**  Procedure  enpiler
 *   Ajoute un Etat à une Pile
 *
 *   Paramètres:
 *              Pile *p: la pile dans laquelle on veut ajouter un Etat.
 *            
 *              Etat *e: L'Etat à ajouter. 
 * 
 *   
 */


void empiler(Pile *p, Etat *e);

/**  Fonction  depiler
 *   Retire un Etat dans une pile  
 *
 *   Paramètre:
 *              Pile *p: la pile dont il faut retirer un Etat
 * 
 *   Retourne:
 *              Etat * : l'état retiré
 *
 */

Etat *depiler(Pile *p);


/**  Fonction  hauteurMax
 *   Fournit la hauteur de de la plus haute pile  manipulée lors du calcul
 *
 *   Paramètre:
 *              Pile *p: la pile à étudier
 * 
 *   Retourne:
 *              Un entier : La hauteur recherchée
 *              1: si la pile ne contient aucun Etat
 *
 *
 *   La signature forme de la fonction  est   
 *
 *            int hauteurMax(Pile *p);
 * 
 *   L'implémentation effective est réalisé en utilisant une Macro.
 *   Ceci permet d'économiser un appel de fonction, tout en maintenant l'encapsulation.
 *
 */




#define hauteurMax(p) (( p)-> HAUTEUR_MAX_PILE)


#endif










